home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / winterp-1.13 / src-server / w_evnthndlr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-04  |  21.5 KB  |  534 lines
  1. /* -*-C-*-
  2. ********************************************************************************
  3. *
  4. * File:         w_evnthndlr.c
  5. * RCS:          $Header: w_evnthndlr.c,v 1.6 91/03/14 03:13:36 mayer Exp $
  6. * Description:  Interfaces to Xtoolkit Event Handler Routines
  7. * Author:       Niels Mayer, HPLabs
  8. * Created:      Thu Nov 23 06:11:39 1989
  9. * Modified:     Thu Oct  3 20:40:45 1991 (Niels Mayer) mayer@hplnpm
  10. * Language:     C
  11. * Package:      N/A
  12. * Status:       X11r5 contrib tape release
  13. *
  14. * WINTERP Copyright 1989, 1990, 1991 Hewlett-Packard Company (by Niels Mayer).
  15. * XLISP version 2.1, Copyright (c) 1989, by David Betz.
  16. *
  17. * Permission to use, copy, modify, distribute, and sell this software and its
  18. * documentation for any purpose is hereby granted without fee, provided that
  19. * the above copyright notice appear in all copies and that both that
  20. * copyright notice and this permission notice appear in supporting
  21. * documentation, and that the name of Hewlett-Packard and David Betz not be
  22. * used in advertising or publicity pertaining to distribution of the software
  23. * without specific, written prior permission.  Hewlett-Packard and David Betz
  24. * make no representations about the suitability of this software for any
  25. * purpose. It is provided "as is" without express or implied warranty.
  26. *
  27. * HEWLETT-PACKARD AND DAVID BETZ DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  28. * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
  29. * IN NO EVENT SHALL HEWLETT-PACKARD NOR DAVID BETZ BE LIABLE FOR ANY SPECIAL,
  30. * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  31. * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  32. * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  33. * PERFORMANCE OF THIS SOFTWARE.
  34. *
  35. * See ./winterp/COPYRIGHT for information on contacting the authors.
  36. * 
  37. * Please send modifications, improvements and bugfixes to mayer@hplabs.hp.com
  38. * Post XLISP-specific questions/information to the newsgroup comp.lang.lisp.x
  39. **
  40. ********************************************************************************
  41. */
  42. static char rcs_identity[] = "@(#)$Header: w_evnthndlr.c,v 1.6 91/03/14 03:13:36 mayer Exp $";
  43.  
  44. #include <stdio.h>
  45. #include <Xm/Xm.h>        /* Xm/Xm.h only needed for "winterp.h"*/
  46. #include "winterp.h"
  47. #include "user_prefs.h"
  48. #include "xlisp/xlisp.h"
  49.  
  50. static LVAL k_RAW, k_NONMASKABLE,
  51.   s_EVHANDLER_WIDGET, s_EVHANDLER_XEVENT, s_EVHANDLER_BUTTON, s_EVHANDLER_TIME,
  52.   s_EVHANDLER;
  53.  
  54. #define RAW_OPTION         (1L<<0)
  55. #define NONMASKABLE_OPTION (1L<<1)
  56.  
  57. extern Widget Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(); /* w_classes.c */
  58.  
  59.  
  60. /******************************************************************************
  61.  * This is an XtEventHandler procedure that is called by the various add-
  62.  * event-handler methods in this file. It serves to call the lisp evaluator
  63.  * on the lexical closure that was created by the add-event-handler-methods.
  64.  * It will bind the symbols EVHANDLER_WIDGET EVHANDLER_XEVENT to
  65.  * the widget and xevent that caused the event handler to fire.
  66. ******************************************************************************/
  67. static void Winterp_Event_Handler_Proc(widget_id, client_data, event)
  68.      Widget    widget_id;
  69.      XtPointer client_data;
  70.      XEvent*   event;
  71. {
  72.   extern LVAL xlenv, xlfenv;
  73.   LVAL        oldenv, oldfenv, l_evalforms, s_name;
  74.   CONTEXT     cntxt;
  75.   LVAL        bindings_list, s_bindname;
  76.   LVAL        c_evhandler = get_evhandler_closure((LVAL) client_data);
  77.  
  78.   /*
  79.    * Most of this procedure looks alot like xleval.c:evfun(), which is what
  80.    * the evaluator calls when a functional form is to be evaluated. The
  81.    * main difference is that instead of calling xlabind() to bind the
  82.    * formal parameter symbols of a function to their values in the new
  83.    * lexical environment frame returned by xlframe(getenv(fun)), we 
  84.    * bind symbols on bindings_list...
  85.    */
  86.   
  87.   /* protect some pointers */
  88.   xlstkcheck(3);
  89.   xlsave(oldenv);
  90.   xlsave(oldfenv);
  91.   xlsave(l_evalforms);
  92.   
  93.   /* create a new environment frame */
  94.   oldenv = xlenv;
  95.   oldfenv = xlfenv;
  96.   xlenv = xlframe(getenvt(c_evhandler)); /* note: changed getenv()-->getenvt() due to name conflict with stdlib.h:getenv() */
  97.   xlfenv = getfenv(c_evhandler);
  98.  
  99.   /* bind  local variables specified durng call to :SET/:ADD_EVENT_HANDLER */
  100.   for (bindings_list = getargs(c_evhandler);
  101.        consp(bindings_list); bindings_list = cdr(bindings_list)) {
  102.     s_bindname = car(bindings_list);
  103.     if (s_bindname == s_EVHANDLER_WIDGET) {
  104.       xlpbind(s_bindname, get_evhandler_widget((LVAL) client_data), xlenv);
  105.     }
  106.     else if (s_bindname == s_EVHANDLER_BUTTON) {
  107.       xlpbind(s_bindname, (event) ? cvfixnum((FIXTYPE) ((XButtonEvent*) event)->button) : NIL, xlenv);
  108.     }
  109.     else if (s_bindname == s_EVHANDLER_TIME) {
  110.       xlpbind(s_bindname, (event) ? cvfixnum((FIXTYPE) ((XButtonEvent*) event)->time) : NIL, xlenv);
  111.     }
  112.     else if (s_bindname == s_EVHANDLER_XEVENT) {
  113.       xlpbind(s_bindname, (event) ? cv_xevent(event) : NIL, xlenv);
  114.     }
  115.     else {
  116.       extern char temptext[]; /* from winterp.c */
  117.       sprintf(temptext,
  118.           "Unknown binding name in Event Handler. Valid symbols are [%s %s %s %s].",
  119.           (char*) getstring(getpname(s_EVHANDLER_WIDGET)),
  120.           (char*) getstring(getpname(s_EVHANDLER_BUTTON)),
  121.           (char*) getstring(getpname(s_EVHANDLER_TIME)),
  122.           (char*) getstring(getpname(s_EVHANDLER_XEVENT)));
  123.       xlerror(temptext, s_bindname);
  124.     }
  125.   }
  126.  
  127.   /* setup the implicit block */
  128.   if (s_name = getname(c_evhandler))
  129.     xlbegin(&cntxt, CF_RETURN, s_name);
  130.   
  131.   /* execute the block */
  132.   if (s_name && setjmp(cntxt.c_jmpbuf))
  133.     { }
  134.   else
  135.     for (l_evalforms = getbody(c_evhandler); consp(l_evalforms); 
  136.      l_evalforms = cdr(l_evalforms))
  137.       xleval(car(l_evalforms));
  138.   
  139.   /* finish the block context */
  140.   if (s_name)
  141.     xlend(&cntxt);
  142.   
  143.   /* restore the environment */
  144.   xlenv = oldenv;
  145.   xlfenv = oldfenv;
  146.   
  147.   /* restore the stack */
  148.   xlpopn(3);
  149. }
  150.  
  151.  
  152. /******************************************************************************
  153.  * (send <widget> :ADD_EVENT_HANDLER [:RAW] [:NONMASKABLE] <event_mask>
  154.  *                                   <event_data_bindings_list> <code>)
  155.  * (send <widget> :SET_EVENT_HANDLER [:RAW] [:NONMASKABLE] <event_mask>
  156.  *                                   <event_data_bindings_list> <code>)
  157.  * ==> returns an <EVHANDLEROBJ> which identifies the handler.
  158.  *
  159.  * Optional keyword :RAW indicates that XtAddRawEventHandler() will
  160.  * be invoked so as to not affect the widget's input mask nor for
  161.  * it to select for events. Otherwise XtAddEventHandler() will get 
  162.  * called.
  163.  *
  164.  * Optional keyword :NONMASKABLE indicates that the handler should
  165.  * be called for nonmaskable events.
  166.  * 
  167.  * <event_mask> is a FIXNUM which is the value of the an event mask.
  168.  * event masks may be combined by doing a bitwise or via the xlisp
  169.  * 'logior' function. The following event mask constants have been
  170.  * defined: NO_EVENT_MASK, KEY_PRESS_MASK, KEY_RELEASE_MASK,
  171.  * BUTTON_PRESS_MASK, BUTTON_RELEASE_MASK, ENTER_WINDOW_MASK,
  172.  * LEAVE_WINDOW_MASK, POINTER_MOTION_MASK, POINTER_MOTIONHINT_MASK,
  173.  * BUTTON1_MOTION_MASK, BUTTON2_MOTION_MASK, BUTTON3_MOTION_MASK,
  174.  * BUTTON4_MOTION_MASK, BUTTON5_MOTION_MASK, BUTTON_MOTION_MASK,
  175.  * KEYMAP_STATE_MASK, EXPOSURE_MASK,  VISIBILITY_CHANGE_MASK
  176.  * STRUCTURE_NOTIFY_MASK, RESIZE_REDIRECT_MASK, SUBSTRUCTURE_NOTIFY_MASK
  177.  * SUBSTRUCTURE_REDIRECT_MASK, FOCUS_CHANGE_MASK, PROPERTY_CHANGE_MASK
  178.  * COLORMAP_CHANGE_MASK, OWNER_GRAB_BUTTON_MASK.
  179.  *
  180.  * <event_data_bindings_list> is a list of symbols that get
  181.  * bound to data specific to the action that caused the event
  182.  * handler to fire. These symbols get lexically bound during
  183.  * the execution of the event-handler <code>.
  184.  * Valid symbols are:
  185.  * EVHANDLER_WIDGET -- bound to the widgetobj of the event
  186.  * EVHANDLER_XEVENT -- bound to the XEvent that fired handler.
  187.  * EVHANDLER_BUTTON -- fixnum -- the button or keycode
  188.  * EVHANDLER_TIME   -- fixnum -- the timestamp.
  189.  *
  190.  * <code> is a list of lisp-forms to be evaluated when the eventhandler
  191.  * fires.
  192.  *
  193.  * The eventhandler may be removed by giving the <EVHANDLEROBJ> to
  194.  * procedure REMOVE_EVENT_HANDLER.
  195.  *
  196.  * Note that the :SET_EVENT_HANDLER variant does exactly the same
  197.  * thing as :ADD_EVENT_HANDLER except that it ensure that only one
  198.  * event handler with the given <event_mask>, :RAW and :NONMASKABLE
  199.  * specifications exist on <widget>. It will remove all other matching
  200.  * event handlers in order to set the current event handler. THis
  201.  * function is useful for making interactive changes to an event
  202.  * handler without having to remember to remove the previous
  203.  * handler. Note that :SET_EVENT_HANDLER is slower, so it should 
  204.  * not be used in cases where speed is important.
  205.  *
  206.  * NOTE: the EVHANDLER_TIME and EVHANDLER_BUTTON
  207.  * binding values may return gibberish if the eventhandler returned
  208.  * a event->type that doesn't define those fields. THis is
  209.  * currently just a kludge for motif functions that require
  210.  * the event->button info (popup menus) or event->time info
  211.  * (XmClipboard*). Hopefully I'll come up with something better.
  212.  *
  213.  * void XtAddEventHandler(widget, eventMask, other, proc, closure)
  214.  *     Widget           widget;
  215.  *     EventMask       eventMask;
  216.  *     Boolean         other;
  217.  *     XtEventHandler  proc;
  218.  *     XtPointer       closure;
  219.  * 
  220.  * void XtAddRawEventHandler(widget, eventMask, other, proc, closure)
  221.  *     Widget           widget;
  222.  *     EventMask       eventMask;
  223.  *     Boolean         other;
  224.  *     XtEventHandler  proc;
  225.  *     XtPointer       closure;
  226.  ******************************************************************************/
  227. LVAL Widget_Class_Meta_Method_Add_Event_Handler();
  228. LVAL Widget_Class_Method_ADD_EVENT_HANDLER()
  229. {
  230.   return (Widget_Class_Meta_Method_Add_Event_Handler(FALSE));
  231. }
  232. LVAL Widget_Class_Method_SET_EVENT_HANDLER()
  233. {
  234.   return (Widget_Class_Meta_Method_Add_Event_Handler(TRUE));
  235. }
  236.  
  237. LVAL Widget_Class_Meta_Method_Add_Event_Handler(one_evhandler_per_mask_p)
  238.      Boolean one_evhandler_per_mask_p;
  239. {
  240.   extern LVAL s_lambda, xlenv, xlfenv;
  241.   Boolean raw_p, nonmaskable_p;
  242.   EventMask event_mask;
  243.   Widget widget_id;
  244.   LVAL o_self, l_fargs, l_code, evhandler_obj;
  245.  
  246.   /* get <widget_instance> */
  247.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&o_self);
  248.  
  249.   /* get optional :RAW or :NONMASKABLE keyword args */
  250.   raw_p = nonmaskable_p = FALSE;
  251.   if (moreargs() && ((*xlargv == k_RAW))) {
  252.     nextarg();
  253.     raw_p = TRUE;
  254.   }
  255.   if (moreargs() && ((*xlargv == k_NONMASKABLE))) {
  256.     nextarg();
  257.     nonmaskable_p = TRUE;
  258.   }
  259.   
  260.   /* get required <event_mask> arg, a fixnum */
  261.   event_mask = (EventMask) getfixnum(xlgafixnum());
  262.  
  263.   /* get <event_data_bindings_list> -- args to be bound at call time.
  264.      NOTE: may want to check that these args are valid... No biggie
  265.      though invalid names will get get caught at runtime,
  266.      when the eventhandler fires. */
  267.   l_fargs = xlgalist();        
  268.   
  269.   /* get <code> */
  270.   l_code = xlgalist();
  271.   xllastarg();
  272.  
  273.   /* 
  274.    * if this procedure is being called from the :set_event_handler method 
  275.    * (indicated by one_evhandler_per_mask_p == TRUE), 
  276.    * then remove all eventhandlers on <widget> matching <event_mask>
  277.    * <raw_p> and <nonmaskable_p>.
  278.    */
  279.   if (one_evhandler_per_mask_p) {
  280.     extern LVAL v_savedobjs;    
  281.     int  i = Wso_Hash(o_self);
  282.     LVAL l_hbucket = getelement(v_savedobjs, i); /* a list of objects, including all evhandler-objs on this widget */
  283.     LVAL obj;
  284.     LVAL l_prev = NIL;
  285.     while (l_hbucket) {        /* while there are elements in the hashbucket */
  286.       obj = car(l_hbucket);    /* obj points to cur elt */
  287.       if (evhandlerobj_p(obj)
  288.       && (get_evhandler_mask(obj) == event_mask)
  289.       && (((get_evhandler_options(obj) & RAW_OPTION) ? TRUE : FALSE) == raw_p)
  290.       && (((get_evhandler_options(obj) & NONMASKABLE_OPTION) ? TRUE : FALSE) == nonmaskable_p)
  291.       && (get_evhandler_widget(obj) == o_self)) {
  292.  
  293.     if (get_evhandler_options(obj) & RAW_OPTION)
  294.       XtRemoveRawEventHandler(widget_id, event_mask,
  295.                   ((get_evhandler_options(obj) & NONMASKABLE_OPTION) ? TRUE : FALSE),
  296.                   Winterp_Event_Handler_Proc, (XtPointer) obj);
  297.     else
  298.       XtRemoveEventHandler(widget_id, event_mask,
  299.                    ((get_evhandler_options(obj) & NONMASKABLE_OPTION) ? TRUE : FALSE),
  300.                    Winterp_Event_Handler_Proc, (XtPointer) obj);
  301.  
  302.     l_hbucket = cdr(l_hbucket); /* l_hbucket now points to next elt or NIL */
  303.     if (!l_prev)
  304.       setelement(v_savedobjs, i, l_hbucket); /* remove first, head is now next elt */
  305.     else
  306.       rplacd(l_prev, l_hbucket); /* remove cur, point previous to next */
  307.       }
  308.       else {
  309.     l_prev = l_hbucket;
  310.     l_hbucket = cdr(l_hbucket);
  311.       }
  312.     }
  313.   }
  314.  
  315.   /* 
  316.    * create the client_data to be sent to (*XtEventHandler)()
  317.    * That procedure takes the client_data and extracts the widget-object,
  318.    * and the closure, and uses these to execute the event handler's code.
  319.    */
  320.   xlsave1(evhandler_obj);    /* protect some pointers */
  321.   evhandler_obj = new_evhandlerobj();
  322.   set_evhandler_widget(evhandler_obj, o_self);
  323.   set_evhandler_mask(evhandler_obj, event_mask);
  324.   {
  325.     long options = 0L;
  326.     if (raw_p)
  327.       options |= RAW_OPTION;    /* this bit tells REMOVE_EVENT_HANDLER which removeproc to call */
  328.     if (nonmaskable_p)
  329.       options |= NONMASKABLE_OPTION; /* we need this bit for REMOVE_EVENT_HANDLER */
  330.     set_evhandler_options(evhandler_obj, options);
  331.   }
  332.   set_evhandler_closure(evhandler_obj, 
  333.             xlclose(s_EVHANDLER, s_lambda, l_fargs, l_code, xlenv, xlfenv));
  334.   
  335.   if (raw_p)
  336.     XtAddRawEventHandler(widget_id, event_mask, nonmaskable_p, 
  337.              Winterp_Event_Handler_Proc, (XtPointer) evhandler_obj);
  338.   else
  339.     XtAddEventHandler(widget_id, event_mask, nonmaskable_p, 
  340.               Winterp_Event_Handler_Proc, (XtPointer) evhandler_obj);
  341.  
  342.   /*
  343.    * Enter the evhandler_obj in v_savedobjs, so that it gets marked.
  344.    * This way, it won't be garbage collected while the eventhandler is
  345.    * active. REMOVE_EVENT_HANDLER, and :destroy on the widget will
  346.    * end up removing the evhandlerobj from v_savedobjs,  which will
  347.    * permit it to be garbage collected.
  348.    */
  349.   { 
  350.     int  i = Wso_Hash(o_self);
  351.     LVAL l_hbucket;
  352.     extern LVAL v_savedobjs;
  353.     
  354.     xlsave1(l_hbucket);
  355.     l_hbucket = cons(evhandler_obj, getelement(v_savedobjs, i));
  356.     setelement(v_savedobjs, i, l_hbucket);
  357.     xlpop(/*l_hbucket*/);
  358.   }
  359.  
  360.   xlpop(/*evhandler_obj*/);
  361.   return (evhandler_obj);
  362. }
  363.  
  364. /******************************************************************************
  365.  * (REMOVE_EVENT_HANDLER <EVHANDEROBJ>)
  366.  * returns true.
  367.  *
  368.  * This procedure removes the eventhander corresponding to the 
  369.  * <EVHANDLEROBJ> returned by method :ADD_EVENT_HANDLER
  370.  *
  371.  * void XtRemoveEventHandler(widget, eventMask, other, proc, closure)
  372.  *     Widget          widget;
  373.  *     EventMask      eventMask;
  374.  *     Boolean          other;
  375.  *     XtEventHandler proc;
  376.  *     XtPointer      closure;
  377.  *
  378.  * void XtRemoveRawEventHandler(widget, eventMask, other, proc, closure)
  379.  *     Widget            widget;
  380.  *     EventMask        eventMask;
  381.  *     Boolean            other;
  382.  *     XtEventHandler   proc;
  383.  *     XtPointer    closure;
  384.  ******************************************************************************/
  385. LVAL Weh_Prim_REMOVE_EVENT_HANDLER()
  386. {
  387.   LVAL evhandler_obj;
  388.   LVAL o_widget;
  389.   Widget widget_id;
  390.   Boolean raw_p, nonmaskable_p;
  391.   extern LVAL true;
  392.  
  393.   evhandler_obj = xlga_evhandlerobj();
  394.   xllastarg();
  395.  
  396.   /* check if this evhandler hasn't already been removed */
  397.   if ((o_widget = get_evhandler_widget(evhandler_obj)) == NIL)
  398.     xlerror("EventHandler associated with <evhandlerobj> has already been removed.", evhandler_obj);
  399.   
  400.   /* mark the evhandler_obj as being removed */
  401.   set_evhandler_widget(evhandler_obj, NIL);
  402.   
  403.   {
  404.     long options;
  405.     options = get_evhandler_options(evhandler_obj);
  406.     raw_p = (options & RAW_OPTION) ? TRUE : FALSE;
  407.     nonmaskable_p = (options & NONMASKABLE_OPTION) ? TRUE : FALSE;
  408.   }
  409.  
  410.   if (!(widget_id = get_widgetobj_widgetID(o_widget)))
  411.     xlerror("widget object not properly initialized by :isnew.", o_widget);
  412.   
  413.   if (raw_p)
  414.     XtRemoveRawEventHandler(widget_id, get_evhandler_mask(evhandler_obj),
  415.                 nonmaskable_p, Winterp_Event_Handler_Proc,
  416.                 (XtPointer) evhandler_obj);
  417.   else
  418.     XtRemoveEventHandler(widget_id, get_evhandler_mask(evhandler_obj),
  419.              nonmaskable_p, Winterp_Event_Handler_Proc,
  420.              (XtPointer) evhandler_obj);
  421.                 
  422.   /* remove <evhandler_obj> from v_savedobjs allowing it to be garbage collected */
  423.   {
  424.     extern LVAL v_savedobjs;
  425.     int i = Wso_Hash(o_widget); /* note that we hash all evhandlers on the same widget to the same hashbucket */
  426.     LVAL l_hbucket = getelement(v_savedobjs, i);
  427.     LVAL l_prev = NIL;
  428.  
  429.     while (l_hbucket && (car(l_hbucket) != evhandler_obj)) {
  430.       l_prev = l_hbucket;
  431.       l_hbucket = cdr(l_hbucket);
  432.     }
  433.     if (!l_hbucket)
  434.       xlerror("Internal error in REMOVE_EVENT_HANDLER -- couldn't remove <evhandlerobj> from v_savedobjs. Hash error?",
  435.           evhandler_obj);
  436.     if (!l_prev)        /* first elt matched */
  437.       setelement(v_savedobjs, i, cdr(l_hbucket));
  438.     else
  439.       rplacd(l_prev, cdr(l_hbucket));
  440.   }
  441.   
  442.   return (true);
  443. }
  444.  
  445.  
  446. /******************************************************************************
  447.  * (send <widget> :BUILD_EVENT_MASK)
  448.  * ==> this returns as a FIXNUM the event mask representing the logical OR of
  449.  * all event masks for event handlers registered on <widget>. This includes
  450.  * masks set by XtAddEventHandler(), all event translations & accelerators.
  451.  * 
  452.  * EventMask XtBuildEventMask(widget)
  453.  *     Widget widget;
  454.  ******************************************************************************/
  455. LVAL Widget_Class_Method_BUILD_EVENT_MASK()
  456. {
  457.   LVAL self;
  458.   Widget widget_id;
  459.  
  460.   widget_id = Wcls_Get_WIDGETOBJ_Argument_Returning_Validated_WidgetID(&self);
  461.   xllastarg();
  462.   
  463.   return (cvfixnum((FIXTYPE) XtBuildEventMask(widget_id)));
  464. }
  465.  
  466.  
  467. /******************************************************************************
  468.  *
  469.  ******************************************************************************/
  470. LVAL Weh_Init()
  471. {
  472.   LVAL s_NO_EVENT_MASK = xlenter("NO_EVENT_MASK");
  473.   LVAL s_KEY_PRESS_MASK = xlenter("KEY_PRESS_MASK");
  474.   LVAL s_KEY_RELEASE_MASK = xlenter("KEY_RELEASE_MASK");
  475.   LVAL s_BUTTON_PRESS_MASK = xlenter("BUTTON_PRESS_MASK");
  476.   LVAL s_BUTTON_RELEASE_MASK = xlenter("BUTTON_RELEASE_MASK");
  477.   LVAL s_ENTER_WINDOW_MASK = xlenter("ENTER_WINDOW_MASK");
  478.   LVAL s_LEAVE_WINDOW_MASK = xlenter("LEAVE_WINDOW_MASK");
  479.   LVAL s_POINTER_MOTION_MASK = xlenter("POINTER_MOTION_MASK");
  480.   LVAL s_POINTER_MOTIONHINT_MASK = xlenter("POINTER_MOTIONHINT_MASK");
  481.   LVAL s_BUTTON1_MOTION_MASK = xlenter("BUTTON1_MOTION_MASK");
  482.   LVAL s_BUTTON2_MOTION_MASK = xlenter("BUTTON2_MOTION_MASK");
  483.   LVAL s_BUTTON3_MOTION_MASK = xlenter("BUTTON3_MOTION_MASK");
  484.   LVAL s_BUTTON4_MOTION_MASK = xlenter("BUTTON4_MOTION_MASK");
  485.   LVAL s_BUTTON5_MOTION_MASK = xlenter("BUTTON5_MOTION_MASK");
  486.   LVAL s_BUTTON_MOTION_MASK = xlenter("BUTTON_MOTION_MASK");
  487.   LVAL s_KEYMAP_STATE_MASK = xlenter("KEYMAP_STATE_MASK");
  488.   LVAL s_EXPOSURE_MASK = xlenter("EXPOSURE_MASK");
  489.   LVAL s_VISIBILITY_CHANGE_MASK = xlenter("VISIBILITY_CHANGE_MASK");
  490.   LVAL s_STRUCTURE_NOTIFY_MASK = xlenter("STRUCTURE_NOTIFY_MASK");
  491.   LVAL s_RESIZE_REDIRECT_MASK = xlenter("RESIZE_REDIRECT_MASK");
  492.   LVAL s_SUBSTRUCTURE_NOTIFY_MASK = xlenter("SUBSTRUCTURE_NOTIFY_MASK");
  493.   LVAL s_SUBSTRUCTURE_REDIRECT_MASK = xlenter("SUBSTRUCTURE_REDIRECT_MASK");
  494.   LVAL s_FOCUS_CHANGE_MASK = xlenter("FOCUS_CHANGE_MASK");
  495.   LVAL s_PROPERTY_CHANGE_MASK = xlenter("PROPERTY_CHANGE_MASK");
  496.   LVAL s_COLORMAP_CHANGE_MASK = xlenter("COLORMAP_CHANGE_MASK");
  497.   LVAL s_OWNER_GRAB_BUTTON_MASK = xlenter("OWNER_GRAB_BUTTON_MASK");
  498.  
  499.   setvalue(s_NO_EVENT_MASK, cvfixnum((FIXTYPE) NoEventMask));
  500.   setvalue(s_KEY_PRESS_MASK, cvfixnum((FIXTYPE) KeyPressMask));
  501.   setvalue(s_KEY_RELEASE_MASK, cvfixnum((FIXTYPE) KeyReleaseMask));
  502.   setvalue(s_BUTTON_PRESS_MASK, cvfixnum((FIXTYPE) ButtonPressMask));
  503.   setvalue(s_BUTTON_RELEASE_MASK, cvfixnum((FIXTYPE) ButtonReleaseMask));
  504.   setvalue(s_ENTER_WINDOW_MASK, cvfixnum((FIXTYPE) EnterWindowMask));
  505.   setvalue(s_LEAVE_WINDOW_MASK, cvfixnum((FIXTYPE) LeaveWindowMask));
  506.   setvalue(s_POINTER_MOTION_MASK, cvfixnum((FIXTYPE) PointerMotionMask));
  507.   setvalue(s_POINTER_MOTIONHINT_MASK, cvfixnum((FIXTYPE) PointerMotionHintMask));
  508.   setvalue(s_BUTTON1_MOTION_MASK, cvfixnum((FIXTYPE) Button1MotionMask));
  509.   setvalue(s_BUTTON2_MOTION_MASK, cvfixnum((FIXTYPE) Button2MotionMask));
  510.   setvalue(s_BUTTON3_MOTION_MASK, cvfixnum((FIXTYPE) Button3MotionMask));
  511.   setvalue(s_BUTTON4_MOTION_MASK, cvfixnum((FIXTYPE) Button4MotionMask));
  512.   setvalue(s_BUTTON5_MOTION_MASK, cvfixnum((FIXTYPE) Button5MotionMask));
  513.   setvalue(s_BUTTON_MOTION_MASK, cvfixnum((FIXTYPE) ButtonMotionMask));
  514.   setvalue(s_KEYMAP_STATE_MASK, cvfixnum((FIXTYPE) KeymapStateMask));
  515.   setvalue(s_EXPOSURE_MASK, cvfixnum((FIXTYPE) ExposureMask));
  516.   setvalue(s_VISIBILITY_CHANGE_MASK, cvfixnum((FIXTYPE) VisibilityChangeMask));
  517.   setvalue(s_STRUCTURE_NOTIFY_MASK, cvfixnum((FIXTYPE) StructureNotifyMask));
  518.   setvalue(s_RESIZE_REDIRECT_MASK, cvfixnum((FIXTYPE) ResizeRedirectMask));
  519.   setvalue(s_SUBSTRUCTURE_NOTIFY_MASK, cvfixnum((FIXTYPE) SubstructureNotifyMask));
  520.   setvalue(s_SUBSTRUCTURE_REDIRECT_MASK, cvfixnum((FIXTYPE) SubstructureRedirectMask));
  521.   setvalue(s_FOCUS_CHANGE_MASK, cvfixnum((FIXTYPE) FocusChangeMask));
  522.   setvalue(s_PROPERTY_CHANGE_MASK, cvfixnum((FIXTYPE) PropertyChangeMask));
  523.   setvalue(s_COLORMAP_CHANGE_MASK, cvfixnum((FIXTYPE) ColormapChangeMask));
  524.   setvalue(s_OWNER_GRAB_BUTTON_MASK, cvfixnum((FIXTYPE) OwnerGrabButtonMask));
  525.  
  526.   k_RAW = xlenter(":RAW");
  527.   k_NONMASKABLE = xlenter(":NONMASKABLE");
  528.   s_EVHANDLER_WIDGET = xlenter("EVHANDLER_WIDGET");
  529.   s_EVHANDLER_XEVENT = xlenter("EVHANDLER_XEVENT");
  530.   s_EVHANDLER_BUTTON = xlenter("EVHANDLER_BUTTON");
  531.   s_EVHANDLER_TIME   = xlenter("EVHANDLER_TIME");
  532.   s_EVHANDLER = xlenter("EVHANDLER");
  533. }  
  534.